home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 1 / Cream of the Crop 1.iso / PROGRAM / CBASE102.ARJ / DGOPS.C < prev    next >
Text File  |  1991-09-23  |  9KB  |  364 lines
  1. /*    Copyright (c) 1989 Citadel    */
  2. /*       All Rights Reserved        */
  3.  
  4. /* #ident    "@(#)dgops.c    1.5 - 91/09/23" */
  5.  
  6. #include <ansi.h>
  7.  
  8. /* ansi headers */
  9. #include <ctype.h>
  10. #include <stdio.h>
  11. #ifdef AC_STRING
  12. #include <string.h>
  13. #endif
  14.  
  15. /* library headers */
  16. #include <blkio.h>
  17.  
  18. /* local headers */
  19. #include "btree_.h"
  20.  
  21. /* function declarations */
  22. #ifdef AC_PROTO
  23. static void printkey(FILE *fp, const char *buf, size_t n);
  24. #else
  25. static void printkey();
  26. #endif
  27.  
  28. /*man---------------------------------------------------------------------------
  29. NAME
  30.      bt_dgbtp - btree diagnostics for control structure
  31.  
  32. SYNOPSIS
  33.      #include "btree_.h"
  34.  
  35.      void bt_dgbtp(btp, fp)
  36.      btree_t *btp;
  37.      FILE *fp;
  38.  
  39. DESCRIPTION
  40.      The bt_dgbtp function writes the contents of btree control
  41.      structure btp in a printable format to file fp.
  42.  
  43. SEE ALSO
  44.      bt_dgbtree, bt_dgnode, bt_dgtuple.
  45.  
  46. PORTABILITY WARNING
  47.      bt_dgbtp assumes that size_t is unsigned int.
  48.  
  49. ------------------------------------------------------------------------------*/
  50. #ifdef AC_PROTO
  51. void bt_dgbtp(btree_t *btp, FILE *fp)
  52. #else
  53. void bt_dgbtp(btp, fp)
  54. btree_t *btp;
  55. FILE *fp;
  56. #endif
  57. {
  58.     fputs("------------------------------------\n", fp);
  59.     fputs("| btree control structure contents |\n", fp);
  60.     fputs("|----------------------------------|\n", fp);
  61.     if (!bt_valid(btp)) {
  62.         fprintf(fp, "|  btp          = %p.\n", btp);
  63.         fputs("|  Invalid btree pointer           |\n", fp);
  64.         fputs("------------------------------------\n", fp);
  65.         return;
  66.     }
  67.     fprintf(fp, "|  hdr.flh      = %lu.\n", btp->bthdr.flh);
  68.     fprintf(fp, "|  hdr.m        = %d.\n", btp->bthdr.m);
  69.     fprintf(fp, "|  hdr.keysize  = %u.\n", btp->bthdr.keysize);
  70.     fprintf(fp, "|  hdr.flags    = %Xh.\n", btp->bthdr.flags);
  71.     fprintf(fp, "|  hdr.root     = %lu.\n", btp->bthdr.root);
  72.     fprintf(fp, "|  hdr.first    = %lu.\n", btp->bthdr.first);
  73.     fprintf(fp, "|  hdr.last     = %lu.\n", btp->bthdr.last);
  74.     fprintf(fp, "|  hdr.keycnt   = %lu.\n", btp->bthdr.keycnt);
  75.     fprintf(fp, "|  hdr.height   = %lu.\n", btp->bthdr.height);
  76.     fprintf(fp, "|  bp           = %p.\n", btp->bp);
  77.     fprintf(fp, "|  flags        = %Xh.\n", btp->flags);
  78.     fprintf(fp, "|  fldc         = %d.\n", btp->fldc);
  79.     fprintf(fp, "|  fldv         = %p.\n", btp->fldv);
  80.     fprintf(fp, "|  cbtpos.node  = %lu.\n", btp->cbtpos.node);
  81.     fprintf(fp, "|  cbtpos.key   = %d.\n", btp->cbtpos.key);
  82.     fprintf(fp, "|  cbtnp        = %p.\n", btp->cbtnp);
  83.     fprintf(fp, "|  sp           = %p.\n", btp->sp);
  84.     fputs("------------------------------------\n", fp);
  85.  
  86.     return;
  87. }
  88.  
  89. /*man---------------------------------------------------------------------------
  90. NAME
  91.      bt_dgbtree - btree diagnostics for tree
  92.  
  93. SYNOPSIS
  94.      #include "btree_.h"
  95.  
  96.      int bt_dgbtree(btp, node, fp)
  97.      btree_t *btp;
  98.      bpos_t node;
  99.      FILE *fp;
  100.  
  101. DESCRIPTION
  102.      The bt_dgbtree command dumps the contents of btree file to the
  103.      text file associated with FILE pointer fp.  The contents of each
  104.      node is written, starting with node node and descending in a
  105.      preorder traversal of the tree.
  106.  
  107. SEE ALSO
  108.      bt_dgbtp, bt_dgnode, bt_dgtuple.
  109.  
  110. EXAMPLE
  111.      The following call will display the contents of an entire tree on
  112.      the screen.
  113.  
  114.           bt_dgbtree(btp, btp->bthdr.root, stdout);
  115.  
  116. ------------------------------------------------------------------------------*/
  117. #ifdef AC_PROTO
  118. int bt_dgbtree(btree_t *btp, bpos_t node, FILE *fp)
  119. #else
  120. int bt_dgbtree(btp, node, fp)
  121. btree_t *btp;
  122. bpos_t node;
  123. FILE *fp;
  124. #endif
  125. {
  126.     btnode_t *btnp = NULL;
  127.     int i = 0;
  128.  
  129.     /* check for bottom of tree */
  130.     if (node == NIL) {
  131.         return 0;
  132.     }
  133.  
  134.     /* read node and display */
  135.     btnp = bt_ndalloc(btp);
  136.     if (btnp == NULL) {
  137.         BTEPRINT;
  138.         return -1;
  139.     }
  140.     if (bt_ndget(btp, node, btnp) == -1) {
  141.         BTEPRINT;
  142.         bt_ndfree(btnp);
  143.         return -1;
  144.     }
  145.     fprintf(fp, "Node block:  %lu.\n", node);
  146.     bt_dgnode(btp, btnp, fp);
  147.     fputc('\n', fp);
  148.  
  149.     /* recurse rest of tree */
  150.     for (i = 0; i < btp->bthdr.m; ++i) {
  151.         if (bt_dgbtree(btp, *bt_kychildp(btnp, i), fp) == -1) {
  152.             return -1;
  153.         }
  154.     }
  155.  
  156.     bt_ndfree(btnp);
  157.     btnp = NULL;
  158.  
  159.     return 0;
  160. }
  161.  
  162. /*man---------------------------------------------------------------------------
  163. NAME
  164.      bt_dgnode - btree diagnostics for node
  165.  
  166. SYNOPSIS
  167.      #include "btree_.h"
  168.  
  169.      void bt_dgnode(btp, btnp, fp)
  170.      btree_t *btp;
  171.      btnode_t *btnp;
  172.      FILE *fp;
  173.  
  174. DESCRIPTION
  175.      The bt_dgnode function writes the contents of node btnp of btree
  176.      btp in a printable format to file fp.
  177.  
  178. SEE ALSO
  179.      bt_dgbtp, bt_dgbtree, bt_dgtuple.
  180.  
  181. ------------------------------------------------------------------------------*/
  182. #ifdef AC_PROTO
  183. void bt_dgnode(btree_t *btp, btnode_t *btnp, FILE *fp)
  184. #else
  185. void bt_dgnode(btp, btnp, fp)
  186. btree_t *btp;
  187. btnode_t *btnp;
  188. FILE *fp;
  189. #endif
  190. {
  191.     int i = 0;
  192.  
  193.     fputs("--------------------------\n", fp);
  194.     fputs("| btree node contents    |\n", fp);
  195.     fputs("--------------------------\n", fp);
  196.     if (!bt_valid(btp)) {
  197.         fprintf(fp, "|  btp          = %p.\n", btp);
  198.         fputs("|  Invalid btree pointer |\n", fp);
  199.         fputs("--------------------------\n", fp);
  200.         return;
  201.     }
  202.     if (btnp == NULL) {
  203.         fputs("|  btnp         = NULL   |\n", fp);
  204.         fputs("--------------------------\n", fp);
  205.         return;
  206.     }
  207.     if (btnp->lsib == NIL) {
  208.         fprintf(fp, "|  lsib         = NIL\n");
  209.     } else {
  210.         fprintf(fp, "|  lsib         = %lu\n", btnp->lsib);
  211.     }
  212.     if (btnp->rsib == NIL) {
  213.         fprintf(fp, "|  rsib         = NIL\n");
  214.     } else {
  215.         fprintf(fp, "|  rsib         = %lu\n", btnp->rsib);
  216.     }
  217.     fprintf(fp, "|  n            = %d\n", btnp->n);
  218.     fprintf(fp, "|  keyv         = %p\n", btnp->keyv);
  219.     fprintf(fp, "|  childv       = %p\n", btnp->childv);
  220.     if (btnp->keyv == NULL || btnp->childv == NULL) {
  221.         fputs("--------------------------\n", fp);
  222.         return;
  223.     }
  224.     if (*bt_kychildp(btnp, 0) == NIL) {
  225.         fputs("|  child[0] = NIL\n", fp);
  226.     } else {
  227.         fprintf(fp, "|  child[0] = %lu\n", *bt_kychildp(btnp, 0));
  228.     }
  229.     for (i = 1; (i <= btp->bthdr.m); ++i) {
  230.         fprintf(fp, "|  key[%d] = \"", i);
  231.         printkey(fp, bt_kykeyp(btp, btnp, i), btkeysize(btp));
  232.         fputs("\"\n", fp);
  233.         if (*bt_kychildp(btnp, i) == NIL) {
  234.             fprintf(fp, "|  child[%d] = NIL\n", i);
  235.         } else {
  236.             fprintf(fp, "|  child[%d] = %lu\n", i, *bt_kychildp(btnp, i));
  237.         }
  238.     }
  239.     fputs("--------------------------\n", fp);
  240.  
  241.     return;
  242. }
  243.  
  244. /*man---------------------------------------------------------------------------
  245. NAME
  246.      bt_dgtuple - btree diagnostics for tuple
  247.  
  248. SYNOPSIS
  249.      #include "btree_.h"
  250.  
  251.      void bt_dgtuple(btp, bttplp, fp)
  252.      btree_t *btp;
  253.      bttpl_t *bttplp;
  254.      FILE *fp;
  255.  
  256. DESCRIPTION
  257.      The bt_dgtuple function writes the contents of tuple bttplp of
  258.      btree btp in a printable format to file fp.
  259.  
  260. SEE ALSO
  261.      bt_dgbtp, bt_dgbtree, bt_dgnode.
  262.  
  263. ------------------------------------------------------------------------------*/
  264. #ifdef AC_PROTO
  265. void bt_dgtuple(btree_t *btp, bttpl_t *bttplp, FILE *fp)
  266. #else
  267. void bt_dgtuple(btp, bttplp, fp)
  268. btree_t *btp;
  269. bttpl_t *bttplp;
  270. FILE *fp;
  271. #endif
  272. {
  273.     fputs("--------------------------\n", fp);
  274.     fputs("|btree bttpl contents   |\n", fp);
  275.     fputs("|------------------------|\n", fp);
  276.     if (!bt_valid(btp)) {
  277.         fprintf(fp, "|  btp          = %p.\n", btp);
  278.         fputs("|  Invalid btree pointer |\n", fp);
  279.         fputs("--------------------------\n", fp);
  280.         return;
  281.     }
  282.     if (bttplp == NULL) {
  283.         fputs("|  bttplp       = NULL   |\n", fp);
  284.         fputs("--------------------------\n", fp);
  285.         return;
  286.     }
  287.     if (bttplp->keyp == NULL) {
  288.         fputs("|  bttplp->keyp = NULL   |\n", fp);
  289.         fputs("--------------------------\n", fp);
  290.         return;
  291.     }
  292.     fputs("|  key          = \"", fp);
  293.     printkey(fp, bttplp->keyp, btkeysize(btp));
  294.     fputs("\"\n", fp);
  295.     if (bttplp->child == NIL) {
  296.         fputs("|  child        = NIL    |\n", fp);
  297.     } else {
  298.         fprintf(fp, "|  child        = %lu.\n", bttplp->child);
  299.     }
  300.     fputs("--------------------------\n", fp);
  301.  
  302.     return;
  303. }
  304.  
  305. /* printkey:  print key */
  306. #ifdef AC_PROTO
  307. static void printkey(FILE *fp, const char *buf, size_t n)
  308. #else
  309. static void printkey(fp, buf, n)
  310. FILE *fp;
  311. const char *buf;
  312. size_t n;
  313. #endif
  314. {
  315.     int i = 0;
  316.     int c = 0;
  317.  
  318.     for (i = 0; i < n; ++i) {
  319.         c = buf[i];
  320.         switch (c) {
  321. #ifdef AC_ESCAPE
  322.         case '\a':    /* BEL */
  323.             fprintf(fp, "\\a");
  324.             break;
  325. #endif
  326.         case '\b':    /* BS */
  327.             fprintf(fp, "\\b");
  328.             break;
  329.         case '\f':    /* FF */
  330.             fprintf(fp, "\\f");
  331.             break;
  332.         case '\n':    /* NL */
  333.             fprintf(fp, "\\n");
  334.             break;
  335.         case '\r':    /* CR */
  336.             fprintf(fp, "\\r");
  337.             break;
  338.         case '\t':    /* HT */
  339.             fprintf(fp, "\\t");
  340.             break;
  341. #ifdef AC_ESCAPE
  342.         case '\v':    /* VT */
  343.             fprintf(fp, "\\v");
  344.             break;
  345. #endif
  346.         case '\\':
  347.             fprintf(fp, "\\\\");
  348.             break;
  349.         case '\"':
  350.             fprintf(fp, "\\\"");
  351.             break;
  352.         default:
  353.             if (isprint(c)) {
  354.                 fputc(c, fp);
  355.             } else {
  356.                 fprintf(fp, "\\%.3o", c);
  357.             }
  358.             break;
  359.         }
  360.     }
  361.  
  362.     return;
  363. }
  364.